/**
 * 应用状态管理器 - 统一管理应用的所有状态
 * 替代分散在各个页面的状态管理逻辑
 */
import config from './config.js'

class AppStateManager {
  constructor() {
    this.state = {
      // 服务器状态
      server: {
        isOnline: false,
        lastCheck: null,
        checkInProgress: false
      },
      // 聊天状态  
      chat: {
        isConnected: false,
        currentRoom: null,
        unreadCount: 0,
        reconnectAttempts: 0
      },
      // 用户状态
      user: {
        isLoggedIn: false,
        profile: null
      }
    }
    
    this.callbacks = new Map()
    this.healthCheckTimer = null
    this.baseURL = config.getServerURL()
    
    // 来自server-status-manager的增强功能
    this.statusCallbacks = [] // 兼容旧的回调系统
    this.checkIntervalTime = 120000 // 2分钟检查一次
    this.statusChecked = false
    
    console.log('应用状态管理器初始化完成')
    this.init()
  }

  // 初始化
  async init() {
    // 检查用户登录状态
    this.checkUserLoginStatus()
    
    // 初始健康检查
    await this.checkServerHealth()
    
    // 启动定期健康检查（5分钟间隔，降低频率）
    this.startPeriodicHealthCheck()
  }

  // 订阅状态变化
  subscribe(stateKey, callback) {
    if (!this.callbacks.has(stateKey)) {
      this.callbacks.set(stateKey, [])
    }
    this.callbacks.get(stateKey).push(callback)
    
    // 立即返回当前状态
    callback(this.state[stateKey])
    
    console.log(`新增状态订阅: ${stateKey}, 当前订阅数: ${this.callbacks.get(stateKey).length}`)
  }

  // 取消订阅
  unsubscribe(stateKey, callback) {
    if (this.callbacks.has(stateKey)) {
      const callbacks = this.callbacks.get(stateKey)
      const index = callbacks.indexOf(callback)
      if (index > -1) {
        callbacks.splice(index, 1)
        console.log(`移除状态订阅: ${stateKey}`)
      }
    }
  }

  // 更新状态并通知订阅者
  setState(stateKey, updates) {
    const oldState = { ...this.state[stateKey] }
    this.state[stateKey] = { ...oldState, ...updates }
    
    // 通知订阅者
    this.notifySubscribers(stateKey)
    
    // 如果是服务器状态变化，触发旧的回调系统
    if (stateKey === 'server' && oldState.isOnline !== this.state[stateKey].isOnline) {
      this.statusChecked = true
      this.triggerStatusChange()
    }
    
    console.log(`状态更新: ${stateKey}`, {
      old: oldState,
      new: this.state[stateKey]
    })
  }

  // 通知订阅者
  notifySubscribers(stateKey) {
    if (this.callbacks.has(stateKey)) {
      const callbacks = this.callbacks.get(stateKey)
      callbacks.forEach(callback => {
        try {
          callback(this.state[stateKey])
        } catch (error) {
          console.error(`状态回调执行失败 (${stateKey}):`, error)
        }
      })
    }
  }

  // 统一健康检查方法
  async checkServerHealth() {
    // 防止重复检查
    if (this.state.server.checkInProgress) {
      console.log('健康检查正在进行中，跳过重复检查')
      return this.state.server.isOnline
    }

    // 开发环境下，如果没有设置使用本地服务器，则跳过健康检查（避免CORS错误）
    // #ifdef H5
    if (typeof localStorage !== 'undefined') {
      const useLocal = localStorage.getItem('useLocalServer') === 'true'
      if (!useLocal && this.baseURL.includes('vicp.fun')) {
        console.log('开发环境跳过远程服务器健康检查（避免CORS错误）')
        console.log('提示: 如需启用健康检查，请在控制台执行: localStorage.setItem("useLocalServer", "true") 并启动本地服务器')
        this.setState('server', {
          isOnline: false,
          lastCheck: new Date(),
          checkInProgress: false
        })
        return false
      }
    }
    // #endif

    this.setState('server', { checkInProgress: true })

    try {
      console.log('开始服务器健康检查...')
      
      // 检查网络连接
      const networkInfo = await this.checkNetworkStatus()
      console.log('网络状态:', networkInfo)
      
      if (!networkInfo.isConnected) {
        console.log('网络连接不可用')
        this.setState('server', {
          isOnline: false,
          lastCheck: new Date(),
          checkInProgress: false
        })
        return false
      }

      // 检查服务器健康状态
      const isServerOnline = await this.performHealthCheck()
      
      this.setState('server', {
        isOnline: isServerOnline,
        lastCheck: new Date(),
        checkInProgress: false
      })

      console.log(`服务器健康检查完成: ${isServerOnline ? '在线' : '离线'}`)
      return isServerOnline

    } catch (error) {
      console.error('服务器健康检查失败:', error)
      this.setState('server', {
        isOnline: false,
        lastCheck: new Date(),
        checkInProgress: false
      })
      return false
    }
  }

  // 检查网络状态 (增强版，来自server-status-manager)
  async checkNetworkStatus() {
    return new Promise((resolve) => {
      // #ifdef H5
      // 网页端检查网络连接
      const isOnline = navigator.onLine
      resolve({
        networkType: 'wifi',
        isConnected: isOnline
      })
      // #endif
      
      // #ifdef APP-PLUS || MP
      // App端和小程序端使用uni.getNetworkType
      uni.getNetworkType({
        success: (res) => {
          resolve({
            networkType: res.networkType,
            isConnected: res.networkType !== 'none'
          })
        },
        fail: () => {
          resolve({
            networkType: 'unknown',
            isConnected: false
          })
        }
      })
      // #endif
    })
  }

  // 执行健康检查请求
  async performHealthCheck() {
    const platform = this.getPlatform()
    
    if (platform === 'web') {
      return await this.performWebHealthCheck()
    } else {
      return await this.performAppHealthCheck()
    }
  }

  // Web端健康检查
  async performWebHealthCheck() {
    try {
      const controller = new AbortController()
      const timeoutId = setTimeout(() => controller.abort(), 5000)
      
      const response = await fetch(`${this.baseURL}/health`, {
        method: 'GET',
        headers: { 'Content-Type': 'application/json' },
        signal: controller.signal
      })
      
      clearTimeout(timeoutId)
      return response.ok
      
    } catch (error) {
      console.log('Web端健康检查失败:', error.message)
      return false
    }
  }

  // App端健康检查
  async performAppHealthCheck() {
    try {
      const result = await new Promise((resolve, reject) => {
        uni.request({
          url: `${this.baseURL}/health`,
          method: 'GET',
          timeout: 5000,
          success: (res) => resolve(res),
          fail: (error) => reject(error)
        })
      })
      
      return result.statusCode === 200
      
    } catch (error) {
      console.log('App端健康检查失败:', error)
      return false
    }
  }

  // 获取当前平台
  getPlatform() {
    // #ifdef H5
    return 'web'
    // #endif
    
    // #ifdef APP-PLUS
    return 'app'
    // #endif
    
    // #ifdef MP
    return 'miniprogram'
    // #endif
    
    return 'unknown'
  }

  // 启动定期健康检查
  startPeriodicHealthCheck() {
    if (this.healthCheckTimer) {
      clearInterval(this.healthCheckTimer)
    }
    
    // 5分钟检查一次，大幅降低检查频率
    this.healthCheckTimer = setInterval(() => {
      this.checkServerHealth()
    }, 300000) // 5分钟
    
    console.log('已启动定期健康检查，间隔: 5分钟')
  }

  // 停止定期健康检查
  stopPeriodicHealthCheck() {
    if (this.healthCheckTimer) {
      clearInterval(this.healthCheckTimer)
      this.healthCheckTimer = null
      console.log('已停止定期健康检查')
    }
  }

  // 检查用户登录状态
  checkUserLoginStatus() {
    try {
      const currentUser = uni.getStorageSync('currentUser')
      if (currentUser) {
        const profile = JSON.parse(currentUser)
        this.setState('user', {
          isLoggedIn: true,
          profile: profile
        })
      } else {
        this.setState('user', {
          isLoggedIn: false,
          profile: null
        })
      }
    } catch (error) {
      console.error('检查用户登录状态失败:', error)
      this.setState('user', {
        isLoggedIn: false,
        profile: null
      })
    }
  }

  // 更新用户登录状态
  updateUserLoginStatus(isLoggedIn, profile = null) {
    this.setState('user', {
      isLoggedIn,
      profile
    })
  }

  // 更新聊天连接状态
  updateChatConnectionStatus(isConnected, reconnectAttempts = 0) {
    this.setState('chat', {
      isConnected,
      reconnectAttempts
    })
  }

  // 更新当前聊天房间
  updateCurrentChatRoom(roomId) {
    this.setState('chat', {
      currentRoom: roomId
    })
  }

  // 获取当前状态
  getState(stateKey = null) {
    if (stateKey) {
      return this.state[stateKey]
    }
    return this.state
  }

  // 手动刷新服务器状态
  async refreshServerStatus() {
    console.log('手动刷新服务器状态...')
    return await this.checkServerHealth()
  }

  // 获取平台信息
  getPlatform() {
    // #ifdef H5
    return 'web'
    // #endif
    
    // #ifdef APP-PLUS
    return 'app'
    // #endif
    
    // #ifdef MP
    return 'miniprogram'
    // #endif
    
    return 'unknown'
  }

  // ==================== 兼容server-status-manager的API ====================
  
  // 兼容旧的状态变化回调系统
  onStatusChange(callback) {
    if (typeof callback === 'function') {
      this.statusCallbacks.push(callback)
      // 如果已经检查过状态，立即触发回调
      if (this.statusChecked) {
        callback(this.state.server.isOnline)
      }
    }
  }
  
  // 移除状态变化回调
  offStatusChange(callback) {
    const index = this.statusCallbacks.indexOf(callback)
    if (index > -1) {
      this.statusCallbacks.splice(index, 1)
    }
  }
  
  // 触发状态变化回调
  triggerStatusChange() {
    this.statusCallbacks.forEach(callback => {
      try {
        callback(this.state.server.isOnline)
      } catch (error) {
        console.error('状态变化回调执行失败:', error)
      }
    })
  }
  
  // 兼容旧的getStatus方法
  getStatus() {
    return {
      isOnline: this.state.server.isOnline,
      lastCheck: this.state.server.lastCheck,
      checkInProgress: this.state.server.checkInProgress
    }
  }
  
  // 兼容旧的refreshStatus方法
  async refreshStatus() {
    return await this.refreshServerStatus()
  }

  // 销毁管理器
  destroy() {
    this.stopPeriodicHealthCheck()
    this.callbacks.clear()
    this.statusCallbacks = []
    console.log('应用状态管理器已销毁')
  }
}

// 创建全局单例
const appStateManager = new AppStateManager()

// 导出单例
export default appStateManager 